{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym\n",
    "import sys\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "from collections import defaultdict, namedtuple\n",
    "from matplotlib import pyplot as plt\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "from sklearn import pipeline\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.linear_model import SGDRegressor\n",
    "from sklearn.kernel_approximation import RBFSampler\n",
    "\n",
    "%matplotlib inline\n",
    "matplotlib.style.use(\"ggplot\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[33mWARN: gym.spaces.Box autodetected dtype as <class 'numpy.float32'>. Please provide explicit dtype.\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "env = gym.envs.make(\"MountainCar-v0\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RBFSampler(gamma=0.5, n_components=100, random_state=None)\n",
      "[0.46063438 0.04032445]\n"
     ]
    }
   ],
   "source": [
    "state_samples = np.array([env.observation_space.sample() for x in range(10000)])\n",
    "# Num\tObservation \tMin \tMax\n",
    "# 0 \tposition\t-1.2\t0.6\n",
    "# 1 \tvelocity\t-0.07\t0.07\n",
    "position_max = np.amax(observation_examples[:, 0])\n",
    "position_min = np.amin(observation_examples[:, 0])\n",
    "velocity_max = np.amax(observation_examples[:, 1])\n",
    "velocity_min = np.amin(observation_examples[:, 1])\n",
    "\n",
    "scaler = StandardScaler()\n",
    "scaler.fit(state_samples)\n",
    "scaler_samples = scaler.transform(state_samples)\n",
    "\n",
    "featurizer_state = RBFSampler(gamma=0.5, n_components=100)\n",
    "featurizer_state.fit(scaler_samples)\n",
    "print(featurizer_state)\n",
    "\n",
    "state = env.reset()\n",
    "print(observation_examples[20])\n",
    "featurized = featurizer_state.transform([observation_examples[10]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDRegressor'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode 1 in 200\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode 11 in 200\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode 21 in 200\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode 31 in 200\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode 41 in 200\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode 51 in 200\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode 61 in 200\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode 71 in 200\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 182 timesteps\n",
      "Episode finished after 181 timesteps\n",
      "Episode 81 in 200\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 176 timesteps\n",
      "Episode finished after 185 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 177 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode 91 in 200\n",
      "Episode finished after 146 timesteps\n",
      "Episode finished after 170 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 186 timesteps\n",
      "Episode finished after 174 timesteps\n",
      "Episode finished after 174 timesteps\n",
      "Episode finished after 167 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 195 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode 101 in 200\n",
      "Episode finished after 179 timesteps\n",
      "Episode finished after 189 timesteps\n",
      "Episode finished after 155 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 146 timesteps\n",
      "Episode finished after 174 timesteps\n",
      "Episode finished after 189 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 165 timesteps\n",
      "Episode 111 in 200\n",
      "Episode finished after 176 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 146 timesteps\n",
      "Episode finished after 167 timesteps\n",
      "Episode finished after 174 timesteps\n",
      "Episode finished after 155 timesteps\n",
      "Episode finished after 179 timesteps\n",
      "Episode finished after 189 timesteps\n",
      "Episode finished after 162 timesteps\n",
      "Episode finished after 176 timesteps\n",
      "Episode 121 in 200\n",
      "Episode finished after 110 timesteps\n",
      "Episode finished after 157 timesteps\n",
      "Episode finished after 172 timesteps\n",
      "Episode finished after 174 timesteps\n",
      "Episode finished after 169 timesteps\n",
      "Episode finished after 164 timesteps\n",
      "Episode finished after 151 timesteps\n",
      "Episode finished after 184 timesteps\n",
      "Episode finished after 191 timesteps\n",
      "Episode finished after 174 timesteps\n",
      "Episode 131 in 200\n",
      "Episode finished after 166 timesteps\n",
      "Episode finished after 167 timesteps\n",
      "Episode finished after 174 timesteps\n",
      "Episode finished after 173 timesteps\n",
      "Episode finished after 143 timesteps\n",
      "Episode finished after 182 timesteps\n",
      "Episode finished after 175 timesteps\n",
      "Episode finished after 176 timesteps\n",
      "Episode finished after 185 timesteps\n",
      "Episode finished after 189 timesteps\n",
      "Episode 141 in 200\n",
      "Episode finished after 179 timesteps\n",
      "Episode finished after 121 timesteps\n",
      "Episode finished after 188 timesteps\n",
      "Episode finished after 190 timesteps\n",
      "Episode finished after 174 timesteps\n",
      "Episode finished after 174 timesteps\n",
      "Episode finished after 167 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 168 timesteps\n",
      "Episode finished after 117 timesteps\n",
      "Episode 151 in 200\n",
      "Episode finished after 177 timesteps\n",
      "Episode finished after 156 timesteps\n",
      "Episode finished after 170 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 182 timesteps\n",
      "Episode finished after 166 timesteps\n",
      "Episode finished after 119 timesteps\n",
      "Episode finished after 162 timesteps\n",
      "Episode finished after 111 timesteps\n",
      "Episode finished after 170 timesteps\n",
      "Episode 161 in 200\n",
      "Episode finished after 169 timesteps\n",
      "Episode finished after 158 timesteps\n",
      "Episode finished after 164 timesteps\n",
      "Episode finished after 112 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 185 timesteps\n",
      "Episode finished after 156 timesteps\n",
      "Episode finished after 175 timesteps\n",
      "Episode finished after 177 timesteps\n",
      "Episode finished after 155 timesteps\n",
      "Episode 171 in 200\n",
      "Episode finished after 180 timesteps\n",
      "Episode finished after 185 timesteps\n",
      "Episode finished after 127 timesteps\n",
      "Episode finished after 167 timesteps\n",
      "Episode finished after 191 timesteps\n",
      "Episode finished after 187 timesteps\n",
      "Episode finished after 185 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 177 timesteps\n",
      "Episode finished after 175 timesteps\n",
      "Episode 181 in 200\n",
      "Episode finished after 165 timesteps\n",
      "Episode finished after 178 timesteps\n",
      "Episode finished after 173 timesteps\n",
      "Episode finished after 173 timesteps\n",
      "Episode finished after 169 timesteps\n",
      "Episode finished after 183 timesteps\n",
      "Episode finished after 108 timesteps\n",
      "Episode finished after 111 timesteps\n",
      "Episode finished after 170 timesteps\n",
      "Episode finished after 181 timesteps\n",
      "Episode 191 in 200\n",
      "Episode finished after 162 timesteps\n",
      "Episode finished after 118 timesteps\n",
      "Episode finished after 171 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 191 timesteps\n",
      "Episode finished after 187 timesteps\n",
      "Episode finished after 179 timesteps\n",
      "Episode finished after 199 timesteps\n",
      "Episode finished after 144 timesteps\n",
      "Episode finished after 163 timesteps\n",
      "MountainCar game iter average time is: 182.77\n"
     ]
    }
   ],
   "source": [
    "class ValueFunction(object):\n",
    "    \"\"\"\n",
    "    Value Funciton approximator.\n",
    "    \"\"\"\n",
    "    def __init__(self):\n",
    "        # sampleing envrionment state in order to featurize it. \n",
    "        state_samples = np.array([env.observation_space.sample() for x in range(10000)])\n",
    "\n",
    "        # Standardize features by removing the mean and scaling to unit variance\n",
    "        self.scaler = StandardScaler()\n",
    "        self.scaler.fit(state_samples)\n",
    "        scaler_samples = scaler.transform(state_samples)\n",
    "\n",
    "        # Approximates feature map of an RBF kernel \n",
    "        # by Monte Carlo approximation of its Fourier transform. \n",
    "        self.featurizer_state = RBFSampler(gamma=0.5, n_components=100)\n",
    "        self.featurizer_state.fit(scaler_samples)\n",
    "\n",
    "        # action model for SGD regressor\n",
    "        self.action_models = []\n",
    "        nA = env.action_space.n\n",
    "        for na in range(nA):\n",
    "            # Linear classifiers with SGD training.\n",
    "            model = SGDRegressor(learning_rate=\"constant\")\n",
    "            model.partial_fit([self.__featurize_state(env.reset())], [0])\n",
    "            self.action_models.append(model)\n",
    "        \n",
    "        # print(self.action_models)\n",
    "            \n",
    "    def __featurize_state(self, state):\n",
    "        scaler_state = self.scaler.transform([state])\n",
    "        return self.featurizer_state.transform(scaler_state)[0]\n",
    "    \n",
    "    def predict(self, state):\n",
    "        curr_features = self.__featurize_state(state)\n",
    "        action_probs = np.array([m.predict([curr_features])[0] for m in self.action_models])\n",
    "        # print(action_probs)\n",
    "        return action_probs\n",
    "\n",
    "    def update(self, state, action, y):\n",
    "        curr_features = self.__featurize_state(state)\n",
    "        self.action_models[action].partial_fit([curr_features], [y])\n",
    "        \n",
    "class QLearning():\n",
    "    def __init__(self, env, num_episodes, discount=1.0, alpha=0.5, epsilon=0.1, ep_decay=1.0):\n",
    "        self.nA = env.action_space.n\n",
    "        self.nS = env.observation_space.shape[0]\n",
    "        self.env = env\n",
    "        self.num_episodes = num_episodes\n",
    "        self.discount = discount\n",
    "        self.alpha = alpha\n",
    "        self.epsilon = epsilon\n",
    "        self.vfa = ValueFunction()\n",
    "        self.ep_decay = ep_decay\n",
    "        \n",
    "        # Keeps track of useful statistics\n",
    "        record = namedtuple(\"Record\", [\"episode_lengths\",\"episode_rewards\"])\n",
    "        self.rec = record(episode_lengths=np.zeros(num_episodes),\n",
    "                          episode_rewards=np.zeros(num_episodes))\n",
    "        \n",
    "    def __epislon_greedy_policy(self, epsilon, nA):\n",
    "\n",
    "        def policy(state):\n",
    "            A = np.ones(nA, dtype=float) * epsilon / nA\n",
    "            Q = self.vfa.predict(state)\n",
    "            best_action = np.argmax(Q)\n",
    "            A[best_action] += (1.0 - epsilon)\n",
    "            return A\n",
    "\n",
    "        return policy\n",
    "\n",
    "    def __next_action(self, prob):\n",
    "        return np.random.choice(np.arange(len(prob)), p=prob)\n",
    "\n",
    "    def qlearning(self):\n",
    "        \"\"\"\n",
    "        Q-learning algo\n",
    "        \"\"\"\n",
    "        sumlist = []\n",
    "\n",
    "        for i_episode in range(self.num_episodes):\n",
    "            # Print out which episode we are on\n",
    "            if 0 == (i_episode) % 10:\n",
    "                print(\"Episode {} in {}\".format(i_episode+1, self.num_episodes))\n",
    "                # sys.stdout.flush()\n",
    "            \n",
    "            # following current policy\n",
    "            policy_epsilon = self.epsilon*self.ep_decay**i_episode\n",
    "            policy = self.__epislon_greedy_policy(policy_epsilon, self.nA)\n",
    "            \n",
    "            step = 0\n",
    "            # Initialize S\n",
    "            state = self.env.reset()\n",
    "            \n",
    "            # Repeat (for each step of episode)\n",
    "            while(True):\n",
    "                # Choose A from S using policy derived from Q\n",
    "                prob_actions = policy(state)\n",
    "                action = self.__next_action(prob_actions)\n",
    "                \n",
    "                # Take action A, observe R, S'\n",
    "                next_state, reward, done, info = env.step(action)\n",
    "                \n",
    "                # update history record\n",
    "                self.rec.episode_lengths[i_episode] += reward\n",
    "                self.rec.episode_rewards[i_episode] = step\n",
    "                \n",
    "                # TD update: Q(S; A)<-Q(S; A) + aplha*[R + discount * max Q(S'; a) − Q(S; A)]\n",
    "                q_next_value = self.vfa.predict(next_state)\n",
    "                td_target = reward + self.discount * np.max(q_next_value)\n",
    "                self.vfa.update(state, action, td_target)\n",
    "                \n",
    "                if done:\n",
    "                    # until S is terminal\n",
    "                    print(\"Episode finished after {} timesteps\".format(step))\n",
    "                    sumlist.append(step)\n",
    "                    break\n",
    "                else:\n",
    "                    step += 1\n",
    "                    # S<-S'\n",
    "                    state = next_state\n",
    "                    \n",
    "        iter_time = sum(sumlist)/len(sumlist)\n",
    "        print(\"MountainCar game iter average time is: {}\".format(iter_time))\n",
    "\n",
    "cls_qlearning = QLearning(env, num_episodes=200)\n",
    "cls_qlearning.qlearning()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x158fe8d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x184edb38>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(<matplotlib.figure.Figure at 0x158fe8d0>,\n",
       " <matplotlib.figure.Figure at 0x184edb38>)"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "import pandas as pd\n",
    "\n",
    "def plot_episode_stats(stats, smoothing_window=10, noshow=False):\n",
    "    # Plot the episode length over time\n",
    "    fig1 = plt.figure(figsize=(10,5))\n",
    "    plt.plot(stats.episode_lengths[:200])\n",
    "    plt.xlabel(\"Episode\")\n",
    "    plt.ylabel(\"Episode Length\")\n",
    "    plt.title(\"Episode Length over Time\")\n",
    "    if noshow:\n",
    "        plt.close(fig1)\n",
    "    else:\n",
    "        plt.show(fig1)\n",
    "\n",
    "    # Plot the episode reward over time\n",
    "    fig2 = plt.figure(figsize=(10,5))\n",
    "    rewards_smoothed = pd.Series(stats.episode_rewards[:200]).rolling(smoothing_window, min_periods=smoothing_window).mean()\n",
    "    plt.plot(rewards_smoothed)\n",
    "    plt.xlabel(\"Episode\")\n",
    "    plt.ylabel(\"Episode Reward\")\n",
    "    plt.title(\"Episode Reward over Time\".format(smoothing_window))\n",
    "    if noshow:\n",
    "        plt.close(fig2)\n",
    "    else:\n",
    "        plt.show(fig2)\n",
    "\n",
    "    return fig1, fig2\n",
    "\n",
    "plot_episode_stats(cls_qlearning.rec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
